package edu.sias.article.controller;


import edu.sias.article.entity.Article;
import edu.sias.article.entity.Comment;
import edu.sias.article.service.ArticleService;
import edu.sias.article.vo.ArticleVO;
import edu.sias.article.vo.CommentVO;
import edu.sias.common.annotation.Log;
import edu.sias.common.core.domain.AjaxResult;
import edu.sias.common.enums.BusinessType;
import edu.sias.common.utils.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

import static edu.sias.common.utils.PageUtils.startPage;

/**
 * 文章控制器，使用 @RestController 注解标记为 RESTful 风格的控制器，处理与文章相关的 HTTP 请求
 */
@RestController
@RequestMapping("/articles")
public class ArticleController {
    /**
     * 自动注入文章服务实例，用于调用服务层的业务逻辑方法
     */
    @Autowired
    private ArticleService articleService;

    /**
     * 将 Article 实体类转换为 ArticleVO 视图对象
     * @param article 文章实体对象
     * @return 文章视图对象
     */
    private ArticleVO convertToArticleVO(Article article) {
        ArticleVO articleVO = new ArticleVO();
        articleVO.setId(article.getId());
        articleVO.setTitle(article.getTitle());
        articleVO.setContent(article.getContent());
        articleVO.setComments(article.getComments().stream()
                .map(this::convertToCommentVO)
                .collect(Collectors.toList()));
        return articleVO;
    }

    /**
     * 将 Comment 实体类转换为 CommentVO 视图对象
     * @param comment 评论实体对象
     * @return 评论视图对象
     */
    private CommentVO convertToCommentVO(Comment comment) {
        CommentVO commentVO = new CommentVO();
        commentVO.setId(comment.getId());
        commentVO.setContent(comment.getContent());
        commentVO.setCommentDate(comment.getCommentDate());
        return commentVO;
    }

    /**
     * 处理创建文章的 POST 请求，调用 ArticleService 的 createArticle 方法创建文章
     * @param article 从请求体中获取的文章对象
     * @return 包含创建成功后文章视图对象的响应实体，状态码为 201 Created
     */

    @PostMapping
    public AjaxResult createArticle(@RequestBody Article article) {
        try {
            // 获取当前登录用户的 ID
            Long currentUserId = SecurityUtils.getUserId();
            article.setUserId(currentUserId); // 设置用户 ID

            Article savedArticle = articleService.createArticle(article);
            ArticleVO articleVO = convertToArticleVO(savedArticle);
            return AjaxResult.success(articleVO);
        } catch (Exception e) {
            return AjaxResult.error("创建文章失败: " + e.getMessage());
        }
    }


    /**
     * 处理获取所有文章的 GET 请求，调用 ArticleService 的 getArticles 方法获取所有文章，并转换为 ArticleVO 列表
     * @return 包含所有文章视图对象列表的响应实体，状态码为 200 OK
     */
    @GetMapping
    public AjaxResult getArticles() {
        try {
            startPage();
            List<Article> articles = articleService.getArticles();
            List<ArticleVO> articleVOs = articles.stream()
                    .map(this::convertToArticleVO)
                    .collect(Collectors.toList());
            return AjaxResult.success(articleVOs);
        } catch (Exception e) {
            return AjaxResult.error("获取文章列表失败: " + e.getMessage());
        }
    }

    /**
     * 处理根据文章 ID 获取文章的 GET 请求，调用 ArticleService 的 getArticleById 方法查询文章，并转换为 ArticleVO
     * @param id 文章的唯一标识符，从路径变量中获取
     * @return 包含文章视图对象的响应实体，如果文章存在则状态码为 200 OK，若不存在则状态码为 404 Not Found
     */
    @GetMapping("/{id}")
    public AjaxResult getArticle(@PathVariable Long id) {
        try {
            Optional<Article> articleOptional = articleService.getArticleById(id);
            if (articleOptional.isPresent()) {
                ArticleVO articleVO = convertToArticleVO(articleOptional.get());
                return AjaxResult.success(articleVO);
            } else {
                return AjaxResult.notFound("文章未找到");
            }
        } catch (Exception e) {
            return AjaxResult.error("获取文章失败: " + e.getMessage());
        }
    }

    /**
     * 处理更新文章信息的 PUT 请求，调用 ArticleService 的 updateArticle 方法更新文章信息，并转换为 ArticleVO
     * @param id 文章的唯一标识符，从路径变量中获取
     * @param updatedArticle 从请求体中获取的包含更新信息的文章对象
     * @return 包含更新后文章视图对象的响应实体，如果文章存在则状态码为 200 OK，若不存在则状态码为 404 Not Found
     */
    @PreAuthorize("@ss.hasPermi('hyzn:article:edit')")
    @Log(title = "文章信息", businessType = BusinessType.UPDATE)
    @PutMapping("/{id}")
    public AjaxResult updateArticle(@PathVariable Long id, @RequestBody Article updatedArticle) {
        try {
            // 获取当前登录用户的 ID
            Long currentUserId = SecurityUtils.getUserId();

            // 根据文章 ID 查询文章信息
            Optional<Article> articleOptional = articleService.getArticleById(id);
            if (!articleOptional.isPresent()) {
                return AjaxResult.notFound("文章未找到");
            }

            Article existingArticle = articleOptional.get();

            // 检查文章是否属于当前用户
//            if (!existingArticle.getUserId().equals(currentUserId)) {
//                return AjaxResult.error("你没有权限更新这篇文章");
//            }

            // 检查并更新 title
            if (updatedArticle.getTitle() != null && !updatedArticle.getTitle().equals(existingArticle.getTitle())) {
                existingArticle.setTitle(updatedArticle.getTitle());
            }

            // 检查并更新 content
            if (updatedArticle.getContent() != null && !updatedArticle.getContent().equals(existingArticle.getContent())) {
                existingArticle.setContent(updatedArticle.getContent());
            }

            // 如果有实际的更新，则进行更新操作
            if (!existingArticle.getTitle().equals(updatedArticle.getTitle()) ||
                    !existingArticle.getContent().equals(updatedArticle.getContent())) {
                articleService.updateArticle(id, existingArticle);
            }

            ArticleVO articleVO = convertToArticleVO(existingArticle);
            return AjaxResult.success(articleVO);
        } catch (Exception e) {
            return AjaxResult.error("更新文章失败: " + e.getMessage());
        }
    }


    /**
     * 处理删除文章的 DELETE 请求，调用 ArticleService 的 deleteArticle 方法删除文章
     * @param id 文章的唯一标识符，从路径变量中获取
     * @return 状态码为 204 No Content 的响应实体，表示删除成功
     */
    @PreAuthorize("@ss.hasPermi('hyzn:article:remove')")
    @Log(title = "文章信息", businessType = BusinessType.DELETE)

    @DeleteMapping("/{id}")
    public AjaxResult deleteArticle(@PathVariable Long id) {
        try {
            // 获取当前登录用户的 ID
            Long currentUserId = SecurityUtils.getUserId();

            // 根据文章 ID 查询文章信息
            Optional<Article> articleOptional = articleService.getArticleById(id);
            if (!articleOptional.isPresent()) {
                return AjaxResult.notFound("文章不存在");
            }

            Article article = articleOptional.get();

            // 检查文章是否属于当前用户
//            if (!article.getUserId().equals(currentUserId)) {
//                return AjaxResult.error("你没有权限删除这篇文章");
//            }

            // 执行删除操作
            articleService.deleteArticle(id);
            return AjaxResult.success("文章删除成功");
        } catch (Exception e) {
            return AjaxResult.error("删除文章失败: " + e.getMessage());
        }
    }


    /**
     * 处理为文章添加评论的 POST 请求，调用 ArticleService 的 addCommentToArticle 方法添加评论，并转换为 ArticleVO
     * @param id 文章的唯一标识符，从路径变量中获取
     * @param commentContent 从请求体中获取的评论内容
     * @return 包含添加评论后文章视图对象的响应实体，如果文章存在则状态码为 200 OK，若不存在则状态码为 404 Not Found
     */
    @PostMapping("/{id}/comments")
    public ResponseEntity<ArticleVO> addComment(@PathVariable Long id, @RequestBody String commentContent) {
        try {
            // 获取当前登录用户的 ID
            Long currentUserId = SecurityUtils.getUserId();

            Optional<Article> articleOptional = articleService.addCommentToArticle(id, commentContent, currentUserId);
            if (articleOptional.isPresent()) {
                ArticleVO articleVO = convertToArticleVO(articleOptional.get());
                return new ResponseEntity<>(articleVO, HttpStatus.OK);
            } else {
                return new ResponseEntity<>(HttpStatus.NOT_FOUND);
            }
        } catch (Exception e) {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

}
